package com.nari.ies.ne.nw.server.service.fileDataCheck.impl;

import com.nari.ies.ne.nw.server.entity.FileDataCheckEntity;
import com.nari.ies.ne.nw.server.mapper.FileDataCheckMapper;
import com.nari.ies.ne.nw.server.mapper.PlantDataMapper;
import com.nari.ies.ne.nw.server.service.fileDataCheck.IGFNBQHLXFileDataCheckService;
import com.nari.ies.ne.nw.server.util.DataUtil;
import com.nari.ies.ne.nw.server.util.IoUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class GFNBQHLXFileDataCheckServiceImpl implements IGFNBQHLXFileDataCheckService {

    @Autowired
    private PlantDataMapper plantDataMapper;

    @Autowired
    private FileDataCheckMapper fileDataCheckMapper;
    @Override
    public void GFNBQHLXFileDataCheck(File file) {
        log.info("数据评分--------------------" + file.getName());
        FileDataCheckEntity fileDataCheckEntity;
        List<FileDataCheckEntity> dataList = new ArrayList<>();
        String plantId;//场站id
        Date forecastDate = null;//预测时间
        Date createDate = new Date();//创建时间
        String plantType;//场站类型
        String fileType;//文件类型
        String dataType;//字段类型

        // 单机信息数据评分项----------1
        // 光伏逆变器最大可输出有功(无数据)
        int nbqMaxOutputNoData = 0;
        // 光伏逆变器最大可输出有功(有数据不合格)
        int nbqMaxOutputQualifiedNo = 0;
        // 光伏逆变器最大可输出有功(有数据合格)
        int nbqMaxOutputQualifiedData = 0;

        // 单机信息数据评分项----------2
        // 光伏逆变器并网运行状态(无数据)
        int nbqConnectedNoData = 0;
        // 光伏逆变器并网运行状态(有数据不合格)
        int nbqConnectedQualifiedNo = 0;
        // 光伏逆变器并网运行状态(有数据合格)
        int nbqConnectedQualifiedData = 0;

        // 单机信息数据评分项----------3
        // 光伏逆变器检修(无数据)
        int nbqOverhaulNoData = 0;
        // 光伏逆变器检修(有数据不合格)
        int nbqOverhaulQualifiedNo = 0;
        // 光伏逆变器检修(有数据合格)
        int nbqOverhaulQualifiedData = 0;

        // 单机信息数据评分项----------4
        // 光伏逆变器故障状态(无数据)
        int nbqFaultStatusNoData = 0;
        // 光伏逆变器故障状态(有数据不合格)
        int nbqFaultStatusQualifiedNo = 0;
        // 光伏逆变器故障状态(有数据合格)
        int nbqFaultStatusQualifiedData = 0;

        // 单机信息数据评分项----------5
        // 光伏逆变器限电(无数据)
        int nbqRationingNoData = 0;
        // 光伏逆变器限电(有数据不合格)
        int nbqRationingQualifiedNo = 0;
        // 光伏逆变器限电(有数据合格)
        int nbqRationingQualifiedData = 0;

        // 单机信息数据评分项----------6
        // 光伏逆变器正常停机(无数据)
        int nbqShutdownNoData = 0;
        // 光伏逆变器正常停机(有数据不合格)
        int nbqShutdownQualifiedNo = 0;
        // 光伏逆变器正常停机（有数据合格）
        int nbqShutdownQualifiedData = 0;

        // 单机信息数据评分项----------7
        // 光伏逆变器通信中断(无数据)
        int nbqInterruptionNoData = 0;
        // 光伏逆变器通信中断（有数据不合格）
        int nbqInterruptionQualifiedNo = 0;
        // 光伏逆变器通信中断（有数据合格）
        int nbqInterruptionQualifiedData = 0;

        // 单机信息数据评分项----------8
        // 光伏逆变器所属集电线(无数据)
        int nbqWireStatusNoData = 0;
        // 光伏逆变器所属集电线（有数据不合格）
        int nbqWireStatusQualifiedNo = 0;
        // 光伏逆变器所属集电线（有数据合格）
        int nbqWireStatusQualifiedData = 0;

        String tableName = "HISDB.NW_NE_FILE_DATACHECK_GF_NBQHLX";//表名

        String fileName = file.getName();

        String[] fileNameArr = fileName.split("_");
        // 文件类型
        fileType = fileNameArr[2];
        // 场站类型
        plantType = fileNameArr[0];
        // 场站标识
        String plantCode = fileNameArr[1].split("\\.")[1];

        //String nwCode = fileNameArr[0] + "_" + fileNameArr[1].split("\\.")[0] + ".";
        List<Map<String, Object>> idList = plantDataMapper.selectPlantData(plantCode);

        plantId = idList.get(0).get("ID").toString();
        if (plantId.contains("-")) {
            plantId = plantId.split("-")[0];
        }

        FileReader fr = null;
        BufferedReader br = null;

        try {
            fr = new FileReader(file);
            br = new BufferedReader(fr);

            // 行数据
            String line = "";
            // 光伏逆变器内容数据的大小
            int nbqFileDataSize = 0;
            // 汇流箱内容数据的大小
            int hlxFileDataSize = 0;
            // 区分光伏逆变器或数据内容标识（1：逆变器 2：汇流箱）
            int isNBQOrHLX = 0;
            while ((line = br.readLine()) != null) {
                // 获取文件的创建时间
                if (line.contains("<NBQ")) {
                    forecastDate = DataUtil.queryTime(line);
                }

                // 逆变器
                if (line.contains("<NBQ")) {
                    isNBQOrHLX = 1;
                }

                // 汇流箱
                if (line.contains("<HLX")) {
                    isNBQOrHLX = 2;
                }

                // 读取逆变器标签下一行
                if (line.contains("#") && isNBQOrHLX == 1) {

                    // 光伏逆变器最大可输出有功
                    // 从0开始算，第23个字段
                    if (!" ".equals(line.split("\t")[23]) && !"null".equals(line.split("\t")[23])
                            && !"NULL".equals(line.split("\t")[23])) {
                        if (Float.parseFloat(line.split("\t")[23]) >= 0) {
                            // 光伏逆变器最大可输出有功(有数据合格)
                            nbqMaxOutputQualifiedData++;
                        }
                    }

                    // 光伏逆变器并网运行状态
                    // 从0开始算，第25个字段
                    if (!" ".equals(line.split("\t")[25]) && !"null".equals(line.split("\t")[25])
                            && !"NULL".equals(line.split("\t")[25])) {
                        if (Float.parseFloat(line.split("\t")[25]) == 1 || Float.parseFloat(line.split("\t")[25]) == 0) {
                            // 有且合格
                            nbqConnectedQualifiedData++;
                        }
                    }

                    // 光伏逆变器检修
                    // 从0开始算，第27个字段
                    if (!" ".equals(line.split("\t")[27]) && !"null".equals(line.split("\t")[27])
                            && !"NULL".equals(line.split("\t")[27])) {
                        if (Float.parseFloat(line.split("\t")[27]) == 1 || Float.parseFloat(line.split("\t")[27]) == 0) {
                            // 有且合格
                            nbqOverhaulQualifiedData++;
                        }
                    }

                    // 光伏逆器故变障状态(有数据合格)
                    // 从0开始算，第26个字段
                    if (!" ".equals(line.split("\t")[26]) && !"null".equals(line.split("\t")[26])
                            && !"NULL".equals(line.split("\t")[26])) {
                        if (Float.parseFloat(line.split("\t")[26]) == 1 || Float.parseFloat(line.split("\t")[26]) == 0) {
                            // 有且合格
                            nbqFaultStatusQualifiedData++;
                        }
                    }

                    // 光伏逆变器限电(有数据合格)------待机
                    // 从0开始算，第28个字段
                    if (!" ".equals(line.split("\t")[28]) && !"null".equals(line.split("\t")[28])
                            && !"NULL".equals(line.split("\t")[28])) {
                        if (Float.parseFloat(line.split("\t")[28]) == 1 || Float.parseFloat(line.split("\t")[28]) == 0) {
                            // 有且合格
                            nbqRationingQualifiedData++;
                        }
                    }

                    // 光伏逆变器正常停机（有数据合格）
                    // 从0开始算，第29个字段
                    if (!" ".equals(line.split("\t")[29]) && !"null".equals(line.split("\t")[29])
                            && !"NULL".equals(line.split("\t")[29])) {
                        if (Float.parseFloat(line.split("\t")[29]) == 1 || Float.parseFloat(line.split("\t")[29]) == 0) {
                            // 有且合格
                            nbqShutdownQualifiedData++;
                        }
                    }

                    // 光伏逆变器通信中断（有数据合格）
                    // 从0开始算，第30个字段
                    if (!" ".equals(line.split("\t")[30]) && !"null".equals(line.split("\t")[30])
                            && !"NULL".equals(line.split("\t")[30])) {
                        if (Float.parseFloat(line.split("\t")[30]) == 1 || Float.parseFloat(line.split("\t")[30]) == 0) {
                            // 有且合格
                            nbqInterruptionQualifiedData++;
                        }
                    }

                    if (!" ".equals(line.split("\t")[34]) && !"null".equals(line.split("\t")[34])) {
                        nbqWireStatusQualifiedData++;
                    }

                    // 计算文件中逆变器、汇流箱数据量
                    if (line.contains("#") && isNBQOrHLX == 1) {
                        nbqFileDataSize++;

                    } else if (line.contains("#") && isNBQOrHLX == 2) {
                        hlxFileDataSize++;
                    }
                }
            }

            // 根据id获取光伏逆变器监测数据量  查表
            int nbqDataSize = plantDataMapper.selectNBQNumber(Long.parseLong(plantId));
            // 根据id获取汇流箱监测数据量
            int hlxDataSize = plantDataMapper.selectHLXNumber(Long.parseLong(plantId));

            // 逆变器无数据
            int nbqNoDataNumber = 0;
            // 根据表中逆变器个数  和 文件中逆变器内容条数 比较
            if (nbqDataSize >= 0) {
                nbqNoDataNumber = Math.max(nbqDataSize - nbqFileDataSize, 0);
            }
            // 汇流箱无数据
//            int hlxNoDataNumber = 0;
//            if (hlxDataSize >= 0) {
//                hlxNoDataNumber = Math.max(hlxDataSize - hlxFileDataSize, 0);
//            }

            // 光伏逆变器最大可输出有功
            dataType = "nbqMaxOutput";
            // 光伏逆变器最大可输出有功(无数据)
            nbqMaxOutputNoData = nbqNoDataNumber;
            // 光伏逆变器最大可输出有功(有数据不合格)
            nbqMaxOutputQualifiedNo = nbqFileDataSize - nbqMaxOutputQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqMaxOutputNoData, nbqMaxOutputQualifiedData, nbqMaxOutputQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器并网运行状态
            dataType = "nbqConnected";
            // 光伏逆变器并网运行状态(无数据)
            nbqConnectedNoData = nbqNoDataNumber;
            // 光伏逆变器并网运行状态(有数据不合格)
            nbqConnectedQualifiedNo = nbqFileDataSize - nbqConnectedQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqConnectedNoData, nbqConnectedQualifiedData, nbqConnectedQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器检修
            dataType = "nbqOverhaul";
            // 光伏逆变器检修(无数据)
            nbqOverhaulNoData = nbqNoDataNumber;
            // 光伏逆变器检修(有数据不合格)
            nbqOverhaulQualifiedNo = nbqFileDataSize - nbqOverhaulQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqOverhaulNoData, nbqOverhaulQualifiedData, nbqOverhaulQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器故障状态
            dataType = "nbqFaultStatus";
            // 光伏逆变器故障状态(无数据)
            nbqFaultStatusNoData = nbqNoDataNumber;
            // 光伏逆变器故障状态(有数据不合格)
            nbqFaultStatusQualifiedNo = nbqFileDataSize - nbqFaultStatusQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqFaultStatusNoData, nbqFaultStatusQualifiedData, nbqFaultStatusQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器限电
            dataType = "nbqRationing";
            // 光伏逆变器限电(无数据)
            nbqRationingNoData = nbqNoDataNumber;
            // 光伏逆变器限电(有数据不合格)
            nbqRationingQualifiedNo = nbqFileDataSize - nbqRationingQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqRationingNoData, nbqRationingQualifiedData, nbqRationingQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器正常停机
            dataType = "nbqShutdown";
            // 光伏逆变器正常停机(无数据)
            nbqShutdownNoData = nbqNoDataNumber;
            // 光伏逆变器正常停机(有数据不合格)
            nbqShutdownQualifiedNo = nbqFileDataSize - nbqShutdownQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqShutdownNoData, nbqShutdownQualifiedData, nbqShutdownQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器通信中断
            dataType = "nbqInterruption";
            // 光伏逆变器通信中断(无数据)
            nbqInterruptionNoData = nbqNoDataNumber;
            // 光伏逆变器通信中断(有数据不合格)
            nbqInterruptionQualifiedNo = nbqFileDataSize - nbqInterruptionQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqInterruptionNoData, nbqInterruptionQualifiedData, nbqInterruptionQualifiedNo);
            dataList.add(fileDataCheckEntity);

            // 光伏逆变器所属集电线
            dataType = "nbqWireStatus";
            // 光伏逆变器所属集电线(无数据)
            nbqWireStatusNoData = nbqNoDataNumber;
            // 光伏逆变器所属集电线(有数据不合格)
            nbqWireStatusQualifiedNo = nbqFileDataSize - nbqWireStatusQualifiedData;

            fileDataCheckEntity = DataUtil.getFileDataCheckEntity(plantId, forecastDate, createDate,
                    plantType, fileType, dataType, nbqWireStatusNoData, nbqWireStatusQualifiedData, nbqWireStatusQualifiedNo);
            dataList.add(fileDataCheckEntity);

            int data = fileDataCheckMapper.selectFileDataCheck(plantId, forecastDate, tableName);
            if (data == 0) {
                log.info("数据评分插入--------------"+fileName);
                fileDataCheckMapper.insertFileDataCheck(dataList, tableName);
            }
        } catch(Exception e){
            e.printStackTrace();
        }finally{
            IoUtil.close(br);
            IoUtil.close(fr);
        }
    }
}
